﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Schedule.Planning.Services
{
	public static class PicLibraryIco
	{
		#region Image Task_pin1
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku task_pin1.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Task_pin1_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Task_pin1, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Task_pin1_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\task_pin1.png
		/// </remarks>
		public static System.Drawing.Image Task_pin1_Cached
		{
			get
			{
				if (_Task_pin1 == null) _Task_pin1 = Task_pin1;
				return _Task_pin1;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku task_pin1.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Task_pin1_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Task_pin1_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Task_pin1_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\task_pin1.png
		/// </remarks>
		public static System.Drawing.Image Task_pin1 { get { return _ImageCreateFrom(_Task_pin1_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru task_pin1.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Task_pin1_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Task_pin1_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\task_pin1.png
		/// </remarks>
		public static System.Drawing.Image Task_pin1_FromFile { get { return _ImageCreateFrom(_Task_pin1_string, "task_pin1.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Task_pin1
		/// </summary>
		/// <returns></returns>
		private static string _Task_pin1_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(424);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA0AAAAKCAYAAABv7tTEAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
			sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjLX7mlDAAAArklEQVQoU2NgwAN+/GfQ+P2fweHnfwYDfOrgcj/+MRT8+i/6/9d/WSBm+P/zH8N0vBpBNvwEKv7zvwWMf/83Amv8/o/B");
			sb.Append("A6fGX/8YMkAKYZp+/beD2PafoQGnJpA/QIp+/bcCYpAGDpCG/zV1DMdwavrzP202UCNYIUQzw/+JkxneRscw6GHVBNIAUmRnz7Bq7nyGyUuWMdyua2Q4SZQGmIlAzep4");
			sb.Append("nQSzgag4IVURAGfBgAVm7sG2AAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Task_pin1_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Task_pin1_Reset()
		{
			_Task_pin1 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Task_pin1_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Task_pin1 = null;
		#endregion
		#region Image Task_pin2
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku task_pin2.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Task_pin2_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Task_pin2, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Task_pin2_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\task_pin2.png
		/// </remarks>
		public static System.Drawing.Image Task_pin2_Cached
		{
			get
			{
				if (_Task_pin2 == null) _Task_pin2 = Task_pin2;
				return _Task_pin2;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku task_pin2.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Task_pin2_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Task_pin2_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Task_pin2_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\task_pin2.png
		/// </remarks>
		public static System.Drawing.Image Task_pin2 { get { return _ImageCreateFrom(_Task_pin2_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru task_pin2.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Task_pin2_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Task_pin2_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\task_pin2.png
		/// </remarks>
		public static System.Drawing.Image Task_pin2_FromFile { get { return _ImageCreateFrom(_Task_pin2_string, "task_pin2.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Task_pin2
		/// </summary>
		/// <returns></returns>
		private static string _Task_pin2_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(484);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
			sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjLX7mlDAAAA20lEQVQoU2NggIL/rFuE/kvtav9vcmjxf46tdjBxDPq/+M6l//1O/f9vcfj/f66tn4AaFTAU/WPZzPRfcMeN/67H//83");
			sb.Append("BSnc9h+o0BOrqf/YN7X/59zyH2gtSNF9kFOwKtx/hytyb6vdv2rB6L/GQprHhYWFDbEqPPqBcZ+Lv9A/CQmJ/yIiIv+ACjuBmBFF8YX/DNK7HrMckZWVvQVUtBiooBiI");
			sb.Append("hTFMPP+XoSwgRm65hoZGNBCjmgJTffEfA9O8/TyLgQqSgZgJZ/jtfMjKEZoo6wJUxIJTEVACAJqYVULjvAKnAAAAAElFTkSuQmCC");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Task_pin2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Task_pin2_Reset()
		{
			_Task_pin2 = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Task_pin2_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Task_pin2 = null;
		#endregion
		#region Image Pin_red
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku PinRed.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu Pin_red_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property Pin_red, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Pin_red_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\djs\PinRed.png
		/// </remarks>
		public static System.Drawing.Image Pin_red_Cached
		{
			get
			{
				if (_Pin_red == null) _Pin_red = Pin_red;
				return _Pin_red;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku PinRed.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image Pin_red_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Pin_red_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Pin_red_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\djs\PinRed.png
		/// </remarks>
		public static System.Drawing.Image Pin_red { get { return _ImageCreateFrom(_Pin_red_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru PinRed.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Pin_red_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property Pin_red_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// C:\David\CsProj\GreenSchedule\Schedule\pic\djs\PinRed.png
		/// </remarks>
		public static System.Drawing.Image Pin_red_FromFile { get { return _ImageCreateFrom(_Pin_red_string, "PinRed.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru Pin_red
		/// </summary>
		/// <returns></returns>
		private static string _Pin_red_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(580);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAgAAAALCAYAAABCm8wlAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
			sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjLX7mlDAAABIklEQVQoU2NggIIMDg61S56eX6+0tr7aPXXqgiRvbx2wFCcDA3M7A0PwcQaGDQ+Ymf//lpP7/z8+/v+rKVO+T0pJSWRI");
			sb.Append("k5Nz+ysh8f8NA8P/j0B8G4hvMDL+fwcUO21t/Y5BjoND+GxY2NP/kpL/HwMlbwLxeyB+BsRBjIy9DMzMzIKCHBzHpgUE/P8VGPj/n5DQ/y9AyW9AHMnIuJGBiYmJkYWF");
			sb.Append("xU5ZWelOtIfHvzoPj/8b3N3/r9DU/BXAypoAdqiAAD9/QUH+fU5Ozt2srKwrgBpOAE3eBtSsAVaQkBDf5evrcwQoaQSUYAUq4AXS3CDTGRQVFORqa2ses7GxFQEFWWDh");
			sb.Append("AqdTkpPnWVtb7QTqFsWQBAnIysq2A43UwyoJFAQA5stcTtz/1kAAAAAASUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property Pin_red_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void Pin_red_Reset()
		{
			_Pin_red = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití Pin_red_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _Pin_red = null;
		#endregion
		#region SPOLEČNÉ METODY PRO KONVERZI
		/// <summary>
		/// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
		/// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
		/// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
		/// Pokud soubor neexistuje, nejprve se vytvoří.
		/// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
		/// Obsah obrázku definuje metoda getDataMethod.
		/// </summary>
		/// <param name="getDataMethod"></param>
		/// <param name="cacheFileName"></param>
		/// <returns></returns>
		private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
		{
			System.Drawing.Image image;
			if (cacheFileName == null)
			{
				using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
				{
					image = System.Drawing.Image.FromStream(ms);
				}
				return image;
			}
			string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
			if (!System.IO.File.Exists(fileName))
				System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
			if (System.IO.File.Exists(fileName))
				return Image.FromFile(fileName);
			return null;
		}
		/// <summary>
		/// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
		/// </summary>
		private static string _ImageCacheDir
		{
			get
			{
				string dirName = System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData), "IconCachePlanningIco");
				if (!System.IO.Directory.Exists(dirName))
					System.IO.Directory.CreateDirectory(dirName);
				return dirName;
			}
		}
		/// <summary>
		/// Předpis pro metody, které generují obsah souboru s daty
		/// </summary>
		/// <returns></returns>
		private delegate string _GetStringDelegate();
		/// <summary>
		/// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
		/// </summary>
		/// <param name="data">Vstupní data v kódování Base64</param>
		/// <returns>Icon vytvořená z dat</returns>
		public static System.Drawing.Icon ConvertStringToIcon(string data)
		{
			System.Drawing.Icon icon;
			using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
			{
				icon = new System.Drawing.Icon(ms);
			}
			return icon;
		}
		/// <summary>
		/// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
		/// </summary>
		/// <param name="data">Vstupní data v kódování Base64</param>
		/// <returns>Cursor vytvořený z dat</returns>
		public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
		{
			System.Windows.Forms.Cursor cursor;
			using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
			{
				cursor = new System.Windows.Forms.Cursor(ms);
			}
			return cursor;
		}
		#endregion
	}
}
